TypeScripti otsingualgoritmid: teabeotsingu tüübi rakendamine

Tarkvaraarenduse valdkonnas on tõhus teabeotsing esmatähtis. Otsingualgoritmid toetavad kõike alates e-kaubanduse tooteotsingutest kuni teadmusbaasi päringuteni. TypeScript oma tugeva tüübisüsteemiga pakub võimsat platvormi nende algoritmide rakendamiseks ja optimeerimiseks. See blogipostitus uurib, kuidas kasutada TypeScripti tüübisüsteemi tüübikindlate, suure jõudlusega ja hooldatavate otsingulahenduste loomiseks.

Teabeotsingu kontseptsioonide mõistmine

Enne TypeScripti implementatsioonidesse sukeldumist defineerime mõned teabeotsingu põhimõisted:

• Dokumendid: Infoühikud, mida soovime läbi otsida. Need võivad olla tekstifailid, andmebaasikirjed, veebilehed või mis tahes muu struktureeritud teave.
• Päringud: Kasutajate esitatud otsinguterminid või -fraasid asjakohaste dokumentide leidmiseks.
• Indekseerimine: Andmestruktuuri loomise protsess, mis võimaldab tõhusat otsingut. Levinud lähenemine on pööratud registri loomine, mis kaardistab sõnad dokumentidega, milles need esinevad.
• Järjestamine: Igale dokumendile skoori määramise protsess vastavalt selle asjakohasusele päringu suhtes. Kõrgemad skoorid näitavad suuremat asjakohasust.
• Asjakohasus: Mõõdik selle kohta, kui hästi dokument vastab kasutaja infovajadusele, nagu see on päringus väljendatud.

Otsingualgoritmi valimine

Eksisteerib mitu otsingualgoritmi, millest igal on oma tugevused ja nõrkused. Mõned populaarsed valikud hõlmavad järgmist:

• Lineaarotsing: Lihtsaim lähenemine, mis hõlmab iga dokumendi läbimist ja selle võrdlemist päringuga. See on suurte andmekogumite puhul ebatõhus.
• Binaarotsing: Nõuab andmete sorteerimist ja võimaldab logaritmilist otsinguaega. Sobib sorteeritud massiivide või puude otsimiseks.
• Räsitabeli otsing: Pakub konstantse ajaga keskmist otsingu keerukust, kuid nõuab räsimisfunktsiooni kokkupõrgete hoolikat kaalumist.
• Pööratud registri otsing: Täpsem tehnika, mis kasutab pööratud registrit konkreetseid märksõnu sisaldavate dokumentide kiireks tuvastamiseks.
• Täistekstiotsingumootorid (nt Elasticsearch, Lucene): Väga optimeeritud suuremahuliseks tekstiotsinguks, pakkudes funktsioone nagu tüvivormi leidmine, stoppsõnade eemaldamine ja udune vaste.

Parim valik sõltub sellistest teguritest nagu andmekogumi suurus, uuenduste sagedus ja soovitud otsingu jõudlus.

Põhiline pööratud registri rakendamine TypeScriptis

Demonstreerime TypeScriptis põhilist pööratud registri implementatsiooni. See näide keskendub tekstidokumentide kogumi indekseerimisele ja otsimisele.

Andmestruktuuride defineerimine

Kõigepealt defineerime andmestruktuurid oma dokumentide ja pööratud registri esitamiseks:

            
interface Document {
  id: string;
  content: string;
}

interface InvertedIndex {
  [term: string]: string[]; // Term -> List of document IDs
}

            

              
                Copy
              
            
          

Pööratud registri loomine

Järgmisena loome funktsiooni pööratud registri loomiseks dokumentide loendist:

            
function createInvertedIndex(documents: Document[]): InvertedIndex {
  const index: InvertedIndex = {};

  for (const document of documents) {
    const terms = document.content.toLowerCase().split(/\s+/); // Tokenize the content

    for (const term of terms) {
      if (!index[term]) {
        index[term] = [];
      }
      if (!index[term].includes(document.id)) {
        index[term].push(document.id);
      }
    }
  }

  return index;
}

            

              
                Copy
              
            
          

Pööratud registri otsimine

Nüüd loome funktsiooni pööratud registri otsimiseks päringule vastavate dokumentide leidmiseks:

            
function searchInvertedIndex(index: InvertedIndex, query: string): string[] {
  const terms = query.toLowerCase().split(/\s+/);
  let results: string[] = [];

  if (terms.length > 0) {
    results = index[terms[0]] || [];

    // For multi-word queries, perform intersection of results (AND operation)
    for (let i = 1; i < terms.length; i++) {
      const termResults = index[terms[i]] || [];
      results = results.filter(docId => termResults.includes(docId));
    }
  }

  return results;
}

            

              
                Copy
              
            
          

Kasutusnäide

Siin on näide pööratud registri kasutamisest:

            
const documents: Document[] = [
  { id: \"1\", content: \"This is the first document about TypeScript.\" },
  { id: \"2\", content: \"The second document discusses JavaScript and TypeScript.\" },
  { id: \"3\", content: \"A third document focuses solely on JavaScript.\" },
];

const index = createInvertedIndex(documents);
const query = \"TypeScript document\";
const searchResults = searchInvertedIndex(index, query);

console.log(\"Search results for '\" + query + \"':\", searchResults); // Output: [\"1\", \"2\"]

            

              
                Copy
              
            
          

Otsingutulemuste järjestamine TF-IDF-iga

Põhiline pööratud registri implementatsioon tagastab dokumendid, mis sisaldavad otsingutermineid, kuid see ei järjesta neid asjakohasuse alusel. Otsingukvaliteedi parandamiseks saame tulemuste järjestamiseks kasutada TF-IDF (Term Frequency-Inverse Document Frequency) algoritmi.

TF-IDF mõõdab termini olulisust dokumendis võrreldes selle olulisusega kõigis dokumentides. Terminid, mis esinevad sageli konkreetses dokumendis, kuid harva teistes dokumentides, loetakse asjakohasemaks.

Termini sageduse (TF) arvutamine

Termini sagedus on termini esinemiskordade arv dokumendis, normaliseerituna dokumendis sisalduvate terminite koguarvuga:

            
function calculateTermFrequency(term: string, document: Document): number {
  const terms = document.content.toLowerCase().split(/\s+/);
  const termCount = terms.filter(t => t === term).length;
  return termCount / terms.length;
}

            

              
                Copy
              
            
          

Pööratud dokumendisageduse (IDF) arvutamine

Pööratud dokumendisagedus mõõdab, kui haruldane on termin kõigis dokumentides. See arvutatakse kõigi dokumentide koguarvu logaritmina jagatuna termini sisaldavate dokumentide arvuga:

            
function calculateInverseDocumentFrequency(term: string, documents: Document[]): number {
  const documentCount = documents.length;
  const documentsContainingTerm = documents.filter(document =>
    document.content.toLowerCase().split(/\s+/).includes(term)
  ).length;

  return Math.log(documentCount / (1 + documentsContainingTerm)); // Add 1 to avoid division by zero
}

            

              
                Copy
              
            
          

TF-IDF skoori arvutamine

Termini TF-IDF skoor dokumendis on lihtsalt selle TF- ja IDF-väärtuste korrutis:

            
function calculateTfIdf(term: string, document: Document, documents: Document[]): number {
  const tf = calculateTermFrequency(term, document);
  const idf = calculateInverseDocumentFrequency(term, documents);
  return tf * idf;
}

            

              
                Copy
              
            
          

Dokumentide järjestamine

Dokumentide järjestamiseks nende asjakohasuse alusel päringu suhtes arvutame TF-IDF skoori iga päringus oleva termini kohta igas dokumendis ja liidame skoorid kokku. Kõrgema koguskooriga dokumendid loetakse asjakohasemaks.

            
function rankDocuments(query: string, documents: Document[]): { document: Document; score: number }[] {
  const terms = query.toLowerCase().split(/\s+/);
  const rankedDocuments: { document: Document; score: number }[] = [];

  for (const document of documents) {
    let score = 0;
    for (const term of terms) {
      score += calculateTfIdf(term, document, documents);
    }
    rankedDocuments.push({ document, score });
  }

  rankedDocuments.sort((a, b) => b.score - a.score); // Sort in descending order of score
  return rankedDocuments;
}

            

              
                Copy
              
            
          

Kasutusnäide TF-IDF-iga

            
const rankedResults = rankDocuments(query, documents);

console.log(\"Ranked search results for '\" + query + \"':\");
rankedResults.forEach(result => {
  console.log(`Document ID: ${result.document.id}, Score: ${result.score}`);
});

            

              
                Copy
              
            
          

Koosinussarnasus semantiliseks otsinguks

Kuigi TF-IDF on märksõnapõhiseks otsinguks tõhus, ei hõlma see sõnade semantilist sarnasust. Koosinussarnasust saab kasutada dokumendivektorite võrdlemiseks, kus iga vektor esindab sõnade sagedust dokumendis. Sarnase sõnade jaotusega dokumentidel on kõrgem koosinussarnasus.

Dokumendivektorite loomine

Kõigepealt peame looma kõigi unikaalsete sõnade sõnastiku kõigist dokumentidest. Seejärel saame esitada iga dokumendi vektorina, kus iga element vastab sõnastikus olevale sõnale ja selle väärtus esindab selle sõna termini sagedust või TF-IDF skoori dokumendis.

            
function createVocabulary(documents: Document[]): string[] {
  const vocabulary = new Set();
  for (const document of documents) {
    const terms = document.content.toLowerCase().split(/\s+/);
    terms.forEach(term => vocabulary.add(term));
  }
  return Array.from(vocabulary);
}

function createDocumentVector(document: Document, vocabulary: string[], useTfIdf: boolean, allDocuments: Document[]): number[] {
  const vector: number[] = [];
  for (const term of vocabulary) {
    if(useTfIdf){
        vector.push(calculateTfIdf(term, document, allDocuments));
    } else {
        vector.push(calculateTermFrequency(term, document));
    }

  }
  return vector;
}

            

              
                Copy
              
            
          

Koosinussarnasuse arvutamine

Koosinussarnasus arvutatakse kahe vektori skalaarkorrutisena jagatuna nende pikkuste korrutisega:

            
function cosineSimilarity(vectorA: number[], vectorB: number[]): number {
  if (vectorA.length !== vectorB.length) {
    throw new Error(\"Vectors must have the same length\");
  }

  let dotProduct = 0;
  let magnitudeA = 0;
  let magnitudeB = 0;

  for (let i = 0; i < vectorA.length; i++) {
    dotProduct += vectorA[i] * vectorB[i];
    magnitudeA += vectorA[i] * vectorA[i];
    magnitudeB += vectorB[i] * vectorB[i];
  }

  magnitudeA = Math.sqrt(magnitudeA);
  magnitudeB = Math.sqrt(magnitudeB);

  if (magnitudeA === 0 || magnitudeB === 0) {
    return 0; // Avoid division by zero
  }

  return dotProduct / (magnitudeA * magnitudeB);
}

            

              
                Copy
              
            
          

Järjestamine koosinussarnasuse abil

Dokumentide järjestamiseks koosinussarnasuse abil loome päringu jaoks vektori (käsitades seda dokumendina) ja seejärel arvutame koosinussarnasuse päringuvektori ja iga dokumendivektori vahel. Kõrgema koosinussarnasusega dokumendid loetakse asjakohasemaks.

            
function rankDocumentsCosineSimilarity(query: string, documents: Document[], useTfIdf: boolean): { document: Document; similarity: number }[] {
    const vocabulary = createVocabulary(documents);
    const queryDocument: Document = { id: \"query\", content: query };
    const queryVector = createDocumentVector(queryDocument, vocabulary, useTfIdf, documents);
    const rankedDocuments: { document: Document; similarity: number }[] = [];

    for (const document of documents) {
        const documentVector = createDocumentVector(document, vocabulary, useTfIdf, documents);
        const similarity = cosineSimilarity(queryVector, documentVector);
        rankedDocuments.push({ document, similarity });
    }

    rankedDocuments.sort((a, b) => b.similarity - a.similarity); // Sort in descending order of similarity
    return rankedDocuments;
}

            

              
                Copy
              
            
          

Kasutusnäide koosinussarnasuse abil

            
const rankedResultsCosine = rankDocumentsCosineSimilarity(query, documents, true); //Use TF-IDF for vector creation

console.log(\"Ranked search results (Cosine Similarity) for '\" + query + \"':\");
rankedResultsCosine.forEach(result => {
    console.log(`Document ID: ${result.document.id}, Similarity: ${result.similarity}`);
});

            

              
                Copy
              
            
          

TypeScripti tüübisüsteem parema ohutuse ja hooldatavuse tagamiseks

TypeScripti tüübisüsteem pakub otsingualgoritmide rakendamiseks mitmeid eeliseid:

• Tüübikindlus: TypeScript aitab vigu varakult tabada, jõustades tüübipiiranguid. See vähendab käitusaja erandite riski ja parandab koodi usaldusväärsust.
• Koodi täielikkus: IDE-d saavad pakkuda paremat koodi täielikkust ja soovitusi muutujate ja funktsioonide tüüpide alusel.
• Refaktoreerimise tugi: TypeScripti tüübisüsteem lihtsustab koodi refaktoreerimist vigu sisse viimata.
• Parem hooldatavus: Tüübid pakuvad dokumentatsiooni ja muudavad koodi lihtsamini mõistetavaks ja hooldatavaks.

Tüübi pseudonüümide ja liideste kasutamine

Tüübi pseudonüümid ja liidesed võimaldavad meil defineerida kohandatud tüüpe, mis esindavad meie andmestruktuure ja funktsioonide signatuure. See parandab koodi loetavust ja hooldatavust. Nagu eelmistes näidetes nähtud, suurendavad `Document` ja `InvertedIndex` liidesed koodi selgust.

Geneerilised tüübid taaskasutatavuse jaoks

Geneerilisi tüüpe saab kasutada taaskasutatavate otsingualgoritmide loomiseks, mis töötavad erinevate andmetüüpidega. Näiteks saaksime luua geneerilise otsingufunktsiooni, mis saab otsida läbi numbrimassiivide, stringide või kohandatud objektide.

Diskrimineeritud liittüübid erinevate andmetüüpide käsitlemiseks

Diskrimineeritud liittüüpe saab kasutada erinevat tüüpi dokumentide või päringute esitamiseks. See võimaldab meil käsitleda erinevaid andmetüüpe tüübikindlal viisil.

Jõudluse kaalutlused

Otsingualgoritmide jõudlus on kriitilise tähtsusega, eriti suurte andmekogumite puhul. Kaaluge järgmisi optimeerimistehnikaid:

• Tõhusad andmestruktuurid: Kasutage indekseerimiseks ja otsimiseks sobivaid andmestruktuure. Pööratud registrid, räsitabelid ja puud võivad jõudlust oluliselt parandada.
• Vahemällu salvestamine: Salvestage sageli juurdepääsetavad andmed vahemällu, et vähendada korduvate arvutuste vajadust. Abiks võivad olla teegid nagu `lru-cache` või mälutehnikate kasutamine.
• Asünkroonsed operatsioonid: Kasutage asünkroonseid operatsioone, et vältida põhilõime blokeerimist. See on eriti oluline veebirakenduste puhul.
• Paralleeltöötlus: Kasutage mitut tuuma või lõime otsinguprotsessi paralleelseks muutmiseks. Veebitöötajaid brauseris või töötlemislõimeid Node.js-is saab ära kasutada.
• Optimeerimisteegid: Kaaluge spetsialiseeritud teekide kasutamist tekstitöötluseks, näiteks loomuliku keele töötlemise (NLP) teeke, mis pakuvad optimeeritud implementatsioone tüvivormi leidmiseks, stoppsõnade eemaldamiseks ja muudeks tekstianalüüsi tehnikateks.

Reaalmaailma rakendused

TypeScripti otsingualgoritme saab rakendada erinevates reaalmaailma stsenaariumides:

• E-kaubanduse otsing: E-kaubanduse veebisaitide tooteotsingute toetamine, mis võimaldab kasutajatel kiiresti leida otsitavaid esemeid. Näited hõlmavad toodete otsimist Amazonis, eBay-s või Shopify poodides.
• Teadmusbaasi otsing: Kasutajatele dokumentatsiooni, artiklite ja KKK-de otsimise võimaldamine. Kasutatakse klienditoesüsteemides nagu Zendesk või sisemistes teadmusbaasides.
• Koodiotsing: Arendajate abistamine koodilõikude, funktsioonide ja klasside leidmisel koodibaasis. Integreeritud IDE-desse nagu VS Code ja veebipõhistesse koodihoidlatesse nagu GitHub.
• Ettevõtte otsing: Ühtse otsinguliidese pakkumine teabele juurdepääsuks erinevates ettevõttesüsteemides, nagu andmebaasid, failiserverid ja e-posti arhiivid.
• Sotsiaalmeedia otsing: Kasutajatele võimaluse pakkumine postituste, kasutajate ja teemade otsimiseks sotsiaalmeedia platvormidel. Näited hõlmavad Twitteri, Facebooki ja Instagrami otsingufunktsioone.

Järeldus

TypeScript pakub võimsat ja tüübikindlat keskkonda otsingualgoritmide rakendamiseks. Kasutades TypeScripti tüübisüsteemi, saavad arendajad luua robustseid, suure jõudlusega ja hooldatavaid otsingulahendusi paljude rakenduste jaoks. Alates põhilistest pööratud registritest kuni täiustatud järjestusalgoritmidena nagu TF-IDF ja koosinussarnasus, annab TypeScript arendajatele võimaluse ehitada tõhusaid ja efektiivseid teabeotsingusüsteeme.

See blogipostitus andis põhjaliku ülevaate TypeScripti otsingualgoritmidest, sealhulgas aluseks olevatest kontseptsioonidest, implementatsiooni detailidest ja jõudluse kaalutlustest. Mõistes neid kontseptsioone ja tehnikaid, saavad arendajad luua keerukaid otsingulahendusi, mis vastavad nende rakenduste spetsiifilistele vajadustele.